//---------------------------------------------------------------------------


#pragma hdrstop

#include "WeightLog.h"
#include "CommBase.h"
//#include "Log.h"
#include "Param.h"
//---------------------------------------------------------------------------

#pragma package(smart_init)
extern UINT8 DeviceAddr[3];
TWetLogger* TWetLogger::m_wetObj  = NULL;
TWetLogger* TWetLogger::GetInstance()
{
   if(m_wetObj == NULL)
       m_wetObj = new TWetLogger();
   return   m_wetObj;
}
TWetLogger::TWetLogger():CBusiness()
{

     RetBuf[0] = 0x20;
     RetBuf[1] = 0x15;
     //AnsiString fileStr =    ExtractFileDir(Application->ExeName)+"\\debug_info.txt";
     /*
     if(!FileExists(fileStr))
     {
       flstrem = new TFileStream(fileStr,fmCreate);
     }
     else
     {
        flstrem = new TFileStream(fileStr,fmOpenReadWrite);
     } */
     //log = new LogFile("c:\\1.txt");
    
     m_hdr->m_FrameHeader[0] = 0xFF;
     m_hdr->m_FrameHeader[1] = 0x55;
     m_hdr->m_FrameHeader_Len = 1;
     m_hdr->m_FrameLength = 25;
     m_hdr->m_type = 3;
     isAck = false;

}
void TWetLogger::EnableAck(bool ack)
{


    isAck = ack;
}
TWetLogger::~TWetLogger()
{
    //if(TWetLogger::m_wetObj)
      //delete TWetLogger::m_wetObj;
    delete flstrem;
}


static const UINT8 auchCRCHi_exp[] = {
   0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81,
   0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0,
   0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01,
   0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41,
   0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81,
   0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0,
   0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01,
   0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40,
   0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81,
   0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0,
   0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01,
   0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41,
   0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81,
   0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0,
   0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01,
   0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81, 0x40, 0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41,
   0x00, 0xc1, 0x81, 0x40, 0x01, 0xc0, 0x80, 0x41, 0x01, 0xc0, 0x80, 0x41, 0x00, 0xc1, 0x81,
   0x40
} ;

static const UINT8 auchCRCLo_exp[] = {
   0x00, 0xc0, 0xc1, 0x01, 0xc3, 0x03, 0x02, 0xc2, 0xc6, 0x06, 0x07, 0xc7, 0x05, 0xc5, 0xc4,
   0x04, 0xcc, 0x0c, 0x0d, 0xcd, 0x0f, 0xcf, 0xce, 0x0e, 0x0a, 0xca, 0xcb, 0x0b, 0xc9, 0x09,
   0x08, 0xc8, 0xd8, 0x18, 0x19, 0xd9, 0x1b, 0xdb, 0xda, 0x1a, 0x1e, 0xde, 0xdf, 0x1f, 0xdd,
   0x1d, 0x1c, 0xdc, 0x14, 0xd4, 0xd5, 0x15, 0xd7, 0x17, 0x16, 0xd6, 0xd2, 0x12, 0x13, 0xd3,
   0x11, 0xd1, 0xd0, 0x10, 0xf0, 0x30, 0x31, 0xf1, 0x33, 0xf3, 0xf2, 0x32, 0x36, 0xf6, 0xf7,
   0x37, 0xf5, 0x35, 0x34, 0xf4, 0x3c, 0xfc, 0xfd, 0x3d, 0xff, 0x3f, 0x3e, 0xfe, 0xfa, 0x3a,
   0x3b, 0xfb, 0x39, 0xf9, 0xf8, 0x38, 0x28, 0xe8, 0xe9, 0x29, 0xeb, 0x2b, 0x2a, 0xea, 0xee,
   0x2e, 0x2f, 0xef, 0x2d, 0xed, 0xec, 0x2c, 0xe4, 0x24, 0x25, 0xe5, 0x27, 0xe7, 0xe6, 0x26,
   0x22, 0xe2, 0xe3, 0x23, 0xe1, 0x21, 0x20, 0xe0, 0xa0, 0x60, 0x61, 0xa1, 0x63, 0xa3, 0xa2,
   0x62, 0x66, 0xa6, 0xa7, 0x67, 0xa5, 0x65, 0x64, 0xa4, 0x6c, 0xac, 0xad, 0x6d, 0xaf, 0x6f,
   0x6e, 0xae, 0xaa, 0x6a, 0x6b, 0xab, 0x69, 0xa9, 0xa8, 0x68, 0x78, 0xb8, 0xb9, 0x79, 0xbb,
   0x7b, 0x7a, 0xba, 0xbe, 0x7e, 0x7f, 0xbf, 0x7d, 0xbd, 0xbc, 0x7c, 0xb4, 0x74, 0x75, 0xb5,
   0x77, 0xb7, 0xb6, 0x76, 0x72, 0xb2, 0xb3, 0x73, 0xb1, 0x71, 0x70, 0xb0, 0x50, 0x90, 0x91,
   0x51, 0x93, 0x53, 0x52, 0x92, 0x96, 0x56, 0x57, 0x97, 0x55, 0x95, 0x94, 0x54, 0x9c, 0x5c,
   0x5d, 0x9d, 0x5f, 0x9f, 0x9e, 0x5e, 0x5a, 0x9a, 0x9b, 0x5b, 0x99, 0x59, 0x58, 0x98, 0x88,
   0x48, 0x49, 0x89, 0x4b, 0x8b, 0x8a, 0x4a, 0x4e, 0x8e, 0x8f, 0x4f, 0x8d, 0x4d, 0x4c, 0x8c,
   0x44, 0x84, 0x85, 0x45, 0x87, 0x47, 0x46, 0x86, 0x82, 0x42, 0x43, 0x83, 0x41, 0x81, 0x80,
   0x40
} ;

/*============================================================================*/
// Procedure to check the checksum of the message
UINT16 modrtuChecksum ( UINT8 *chkbuf, UINT8 len )
{

   UINT8    uchCRCHi = 0xff ;
   UINT8    uchCRCLo = 0xff ;
   UINT16  uIndex ;
   UINT16  temp_code;

   while ( len )
      {
      uIndex = (UINT16) ( uchCRCHi ^ *chkbuf++ ) ;

      uchCRCHi = (UINT8) ( uchCRCLo ^ auchCRCHi_exp[uIndex] ) ;
      uchCRCLo = auchCRCLo_exp[uIndex] ;
      len-- ;
      }
   temp_code = (UINT16) uchCRCHi;
   temp_code = (UINT16) (temp_code << 8);
   return(UINT16) (  temp_code | uchCRCLo ) ;
}


struct TDataRecvMgr{
    TDataRecvMgr()
    {
       reset();
    }
    void reset()
    {
        sync = 0;
        slave = 0;
        cmd  = 0;
        pkg_len  = 0;
        wait_flag = 0;
        wait_len = 0;
    }
    void wait()
    {
         wait_flag = 1;
    }
    bool is_wait_complete()
    {
         return wait_flag;
    }
    UINT8 sync;
    UINT8 slave;
    UINT8 cmd;
    UINT8 pkg_len;
    UINT8 wait_len;
    UINT8 wait_flag;
};
static  TDataRecvMgr recvMgr;

int  TWetLogger::DataComplete(TCommunication* comm)
{
    int len =  recvMgr.pkg_len;
    frameBuf[0] = recvMgr.sync;
    frameBuf[1] = recvMgr.slave;
    frameBuf[2] = recvMgr.cmd;
    frameBuf[3] = recvMgr.pkg_len;
    for(UINT32 ii = 4 ;ii < recvMgr.pkg_len; ii++ )
    {
         frameBuf[ii] = m_RecvQue.front();
         m_RecvQue.pop();

    }
    UINT16 crc = modrtuChecksum(frameBuf,len-2);
    UINT16 temp = (frameBuf[len-2]<<8)+frameBuf[len-1];
    if(crc == temp)
    {
         Disposal(comm,frameBuf,len);
    }
    recvMgr.reset();

    return 0;

}
int  TWetLogger::PraseFrame(TCommunication* comm,UINT8* packetBuf, UINT32 len)
{
     //return CBusiness::PraseFrame(comm,packetBuf,  len);
    PushAllData(packetBuf,len);
    size_t size =  m_RecvQue.size();

    while(size > 20){

        if(recvMgr.is_wait_complete()){
                if(recvMgr.wait_len <= size)
                        DataComplete(comm);
                else break;
        }else if(size > 20){

            recvMgr.sync = m_RecvQue.front();
            m_RecvQue.pop();
            if(recvMgr.sync == 0xFF){
                recvMgr.slave = m_RecvQue.front();
                m_RecvQue.pop();
                recvMgr.cmd = m_RecvQue.front();
                m_RecvQue.pop();
                if(recvMgr.cmd == 0x0){
                     recvMgr.pkg_len = m_RecvQue.front();
                     m_RecvQue.pop();
                     recvMgr.wait_len = recvMgr.pkg_len - 4;

                     if(m_RecvQue.size() >= recvMgr.wait_len){
                          DataComplete(comm);
                     }else{
                          recvMgr.wait();
                     }
                }

            }


        }
        size =  m_RecvQue.size();
    }

    return  m_RecvQue.size();

}
void TWetLogger::Disposal(TCommunication* commu,UINT8* packetBuf, UINT32 len)
{
  
    union
	{
	    float fl;
		struct{UINT8 fl1;UINT8 fl2;UINT8 fl3;UINT8 fl4;}sfl;
	}float_add_temp,float_temp;


    TStoreDataInfo info;
    int index = 4;
    info.year =  (packetBuf[index++]<<8);
    info.year += packetBuf[index++];
    info.mon =  packetBuf[index++];
    info.day =  packetBuf[index++];
    info.hour =  packetBuf[index++];
    info.min =  packetBuf[index++];
    info.sec =  packetBuf[index++];

    info.overload = packetBuf[index++];
    info.speed =  (packetBuf[index++]<<8);
    info.speed +=  packetBuf[index++];
    
    info.acc_spd = packetBuf[index++];
    info.axis_num = packetBuf[index++];
    info.axisgrp_num = packetBuf[index++];

    for(int i = 0; i < info.axisgrp_num; i++)
    {
        info.axisgrp_kg[i] = (packetBuf[index++]<<8);
        info.axisgrp_kg[i] += (packetBuf[index++]);
    }

    for(int i = 0; i < info.axisgrp_num; i++)
    {
         info.axisgrp_type[i] = (packetBuf[index++]);
    }

    for(int i = 0; i < (info.axis_num-1); i++ )
    {
         info.axis_dist[i] = (packetBuf[index++]);
    }

    
    
    
    m_frame->SetInfoPacket(info);


    SendRetCode(commu);

    NotifyView(commu,this);

}
void TWetLogger::SendRetCode(TCommunication* commu)
{
    if(!isAck)
      return;
    RetBuf[0] = 0xff;
    RetBuf[1] = 0x00;
    RetBuf[2] = 0x02;
    RetBuf[3] = 0x0;


    UINT8 CheckSum = 0;

    UINT16 crc = modrtuChecksum(RetBuf,4);
    RetBuf[4] = crc>>8;
    RetBuf[5] = crc&0xff;
    commu->WriteBuffer(RetBuf,6);
 
    Sleep(10);
}


